home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / program / misc / smalltlk.lha / Smalltalk3.09 / src / initial.c < prev    next >
C/C++ Source or Header  |  1995-08-26  |  3KB  |  134 lines
  1. /*
  2.     Little Smalltalk, version 3
  3.     Written by Tim Budd, June 1988
  4.  
  5.     initial image maker
  6. */
  7. # include <stdio.h>
  8. # include "env.h"
  9. # include "memory.h"
  10. # include "names.h"
  11.  
  12. int initial = 1;    /* making initial image */
  13.  
  14. /* lightspeed C not using argc/argv features */
  15. # ifdef NOARGC
  16. char *argv[] = {"initial", "basic.st","mag.st","collect.st", "file.st",
  17.         "mult.st", 
  18. # ifdef STDWIN
  19.         "graphics.st", "stdwin.st", 0};
  20. int argc = 8;
  21. # endif
  22. # ifndef STDWIN
  23.         "tty.st", 0};
  24. int argc = 7;
  25. # endif
  26.  
  27. main()
  28. # endif
  29. # ifndef NOARGC
  30. main(argc, argv) 
  31. int argc;
  32. char **argv;
  33. # endif
  34. {     char methbuf[100];
  35.     int i;
  36.  
  37.     initMemoryManager();
  38.  
  39.     makeInitialImage();
  40.  
  41.     initCommonSymbols();
  42.  
  43.     for (i = 1; i < argc; i++) {
  44.         fprintf(stderr,"%s:\n", argv[i]);
  45.         ignore sprintf(methbuf, 
  46.             "x <120 1 '%s' 'r'>. <123 1>. <121 1>", 
  47.                 argv[i]);
  48.         goDoIt(methbuf);
  49.         }
  50.  
  51.     /* when we are all done looking at the arguments, do initialization */
  52.     fprintf(stderr,"initialization\n");
  53.     /*debugging = true;*/
  54.     goDoIt("x nil initialize\n");
  55.     fprintf(stderr,"finished\n");
  56.  
  57.     /* exit and return - belt and suspenders, but it keeps lint happy */
  58.     exit(0); return 0;
  59. }
  60.  
  61. static goDoIt(text)
  62. char *text;
  63. {     object process, stack, method;
  64.  
  65.     method = newMethod();
  66.     incr(method);
  67.     setInstanceVariables(nilobj);
  68.     ignore parse(method, text, false);
  69.  
  70.     process = allocObject(processSize);
  71.     incr(process);
  72.     stack = allocObject(50);
  73.     incr(stack);
  74.  
  75.     /* make a process */
  76.     basicAtPut(process, stackInProcess, stack);
  77.     basicAtPut(process, stackTopInProcess, newInteger(10));
  78.     basicAtPut(process, linkPtrInProcess, newInteger(2));
  79.  
  80.     /* put argument on stack */
  81.     basicAtPut(stack, 1, nilobj);    /* argument */
  82.     /* now make a linkage area in stack */
  83.     basicAtPut(stack, 2, nilobj);    /* previous link */
  84.     basicAtPut(stack, 3, nilobj);    /* context object (nil = stack) */
  85.     basicAtPut(stack, 4, newInteger(1));    /* return point */
  86.     basicAtPut(stack, 5, method);    /* method */
  87.     basicAtPut(stack, 6, newInteger(1));    /* byte offset */
  88.  
  89.     /* now go execute it */
  90.     while (execute(process, 15000)) {
  91.         fprintf(stderr,"..");
  92.         fflush(stderr);
  93.         }
  94. }
  95.  
  96. /*
  97.     there is a sort of chicken and egg problem with regards to making
  98.     the initial image
  99. */
  100. static makeInitialImage()
  101. {    object hashTable;
  102.     object symbolObj, symbolClass, classClass;
  103.  
  104.     /* first create the table, without class links */
  105.     symbols = allocObject(1);
  106.     incr(symbols);
  107.     hashTable = allocObject(3 * 53);
  108.     basicAtPut(symbols, 1, hashTable);
  109.  
  110.     /* next create #Symbol, Symbol and Class */
  111.     symbolObj = newSymbol("Symbol");
  112.     symbolClass = newClass("Symbol");
  113.     setClass(symbolObj, symbolClass);
  114.     classClass = newClass("Class");
  115.     setClass(symbolClass, classClass);
  116.     setClass(classClass, classClass);
  117.  
  118.     /* now fix up classes for symbol table */
  119.     /* and make a couple common classes, just to hold their places */
  120.     ignore newClass("Link");
  121.     ignore newClass("ByteArray");
  122.     setClass(hashTable, newClass("Array"));
  123.     setClass(symbols, newClass("Dictionary"));
  124.     setClass(nilobj, newClass("UndefinedObject"));
  125.     ignore newClass("String");
  126.     nameTableInsert(symbols, strHash("symbols"), newSymbol("symbols"), symbols);
  127.  
  128.     /* finally at least make true and false to be distinct */
  129.     trueobj = newSymbol("true");
  130.     nameTableInsert(symbols, strHash("true"), trueobj, trueobj);
  131.     falseobj = newSymbol("false");
  132.     nameTableInsert(symbols, strHash("false"), falseobj, falseobj);
  133. }
  134.